SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Incremental computing</title>

</head>

<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">Incremental computing</span></span>

</h1>

</header>

<p><b>Incremental computing</b>, also known as <b>incremental computation</b>, is a <a href="Software_feature" title="Software feature">software feature</a> which, whenever a piece of <a href="Data" title="Data">data</a> changes, attempts to save <a href="Time" title="Time">time</a> by only recomputing those outputs which depend on the changed data.<sup id="cite_ref-monads-for-incremental_1-0" class="reference"><a href="#cite_note-monads-for-incremental-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-2" class="reference"><a href="#cite_note-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup> When incremental computing is successful, it can be significantly faster than computing new outputs naively. For example, a <a href="Spreadsheet" title="Spreadsheet">spreadsheet</a> software package might use incremental computation in its recalculation features, to update only those cells containing formulas which depend (directly or indirectly) on the changed cells.

</p><p>When incremental computing is implemented by a tool that can implement it for a variety of different pieces of code automatically, that tool is an example of a <a href="Program_analysis" title="Program analysis">program analysis</a> tool for <a href="Program_optimization" title="Program optimization">optimization</a>.

</p>

<div class="mw-heading mw-heading2"><h2 id="Static_versus_dynamic">Static versus dynamic</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

<p>Incremental computing techniques can be broadly separated into two types of approaches:

</p><p><i><a href="Static_random-access_memory" title="Static random-access memory">Static approaches</a></i> attempt to derive an incremental program from a conventional program P using, e.g., either manual design and refactoring, or automatic program transformations. These program transformations occur before any inputs or input changes are provided.

</p><p><i><a href="Dynamic_approach_to_second_language_development" class="mw-redirect" title="Dynamic approach to second language development">Dynamic approaches</a></i> record information about executing program P on a particular input (I1) and use this information when the input changes (to I2) in order to update the output (from O1 to O2). The figure shows the relationship between program P, the change calculation function ΔP, which constitutes the core of the incremental program, and a pair of inputs and outputs, I1, O1 and I2, O2.

</p>

<div class="mw-heading mw-heading2"><h2 id="Specialized_versus_general-purpose_approaches">Specialized versus general-purpose approaches</h2></div>

<p>Some approaches to incremental computing are specialized, while others are general purpose.

Specialized approaches require the programmer to explicitly specify the <a href="Algorithm" title="Algorithm">algorithms</a> and data structures that will be used to preserve unchanged sub-calculations.

General-purpose approaches, on the other hand, use language, compiler, or algorithmic techniques to give incremental behavior to otherwise non-incremental programs.<sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading2"><h2 id="Static_methods">Static methods</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Program_derivatives">Program derivatives</h3></div>

<p>Given a computation <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle C=f(x_{1},x_{2},\dots x_{n})}">

<msub>

</mrow>

</msub>

<msub>

</mrow>

</msub>

<msub>

</mrow>

</msub>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle C=f(x_{1},x_{2},\dots x_{n})}</annotation>

</semantics>

</math></span><img src="./060d19879420e02acb567f0db07ced3ab26dabad.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:20.447ex; height:2.843ex;" alt="{\displaystyle C=f(x_{1},x_{2},\dots x_{n})}" loading="lazy"></span> and a potential change <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle x_{j}:=\Delta _{x_{j}}}">

<msub>

</mrow>

</msub>

<msub>

<msub>

</mrow>

</msub>

</mrow>

</msub>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle x_{j}:=\Delta _{x_{j}}}</annotation>

</semantics>

</math></span><img src="./b03933e1d7be20c28a22705fd3d049201cd35b71.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -1.171ex; width:9.807ex; height:3.009ex;" alt="{\displaystyle x_{j}:=\Delta _{x_{j}}}" loading="lazy"></span>, we can insert code before the change occurs (the pre-derivative) and after the change (the post-derivative) to update the value of <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle C}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle C}</annotation>

</semantics>

</math></span><img src="./4fc55753007cd3c18576f7933f6f089196732029.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:1.766ex; height:2.176ex;" alt="{\displaystyle C}" loading="lazy"></span> faster than rerunning <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle f}">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle f}</annotation>

</semantics>

</math></span><img src="./132e57acb643253e7810ee9702d9581f159a1c61.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.671ex; width:1.279ex; height:2.509ex;" alt="{\displaystyle f}" loading="lazy"></span>. Paige has written down a list of rules for formal differentiation of programs in SUBSETL.<sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading3"><h3 id="View_maintenance">View maintenance</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

<p>In database systems such as DBToaster, views are defined with relational algebra. Incremental view maintenance statically analyzes relational algebra to create update rules that quickly maintain the view in the presence of small updates, such as insertion of a row.<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading2"><h2 id="Dynamic_methods">Dynamic methods</h2></div>

<p>Incremental computation can be achieved by building a <a href="Dependency_graph" title="Dependency graph">dependency graph</a> of all the data elements that may need to be recalculated, and their dependencies. The elements that need to be updated when a single element changes are given by the <a href="Transitive_closure" title="Transitive closure">transitive closure</a> of the dependency relation of the graph. In other words, if there is a path from the changed element to another element, the latter may be updated (depending on whether the change eventually reaches the element). The dependency graph may need to be updated as dependencies change, or as elements are added to, or removed from, the system. It is used internally by the implementation, and does not typically need to be displayed to the user.

</p><p>Capturing dependencies across all possible values can be avoided by identifying subset of important values (e.g., aggregation results) across which dependencies can be tracked, and incrementally recomputing other dependent variables, hence balancing the amount of dependency information to be tracked with the amount of recomputation to be performed upon input change.<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup>

</p><p><a href="Partial_evaluation" title="Partial evaluation">Partial evaluation</a> can be seen as a method for automating the simplest possible case of incremental computing, in which an attempt is made to divide program data into two categories: that which can vary based on the program's input, and that which cannot (and the smallest unit of change is simply "all the data that can vary"). Partial evaluation can be combined with other incremental computing techniques.

</p><p>With cycles in the dependency graph, a single pass through the graph may not be sufficient to reach a fixed point. In some cases, complete reevaluation of a system is semantically equivalent to incremental evaluation, and may be more efficient in practice if not in theory.<sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup>

</p>

<div class="mw-heading mw-heading2"><h2 id="Existing_systems">Existing systems</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Compiler_and_language_support">Compiler and language support</h3></div>

<ul><li>Automatic Incrementalization (also called "Self-Adjusting Computation", and "Adaptive Functional Programming"),<sup id="cite_ref-HammerAcar2009_9-0" class="reference"><a href="#cite_note-HammerAcar2009-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup> <a href="https://doi.org/10.1007/978-3-642-04652-0_1" class="extiw external" title="doi:10.1007/978-3-642-04652-0 1">Delta ML</a>, <a rel="nofollow" class="external text" href="https://hackage.haskell.org/package/Adaptive">Haskell Adaptive</a></li>

<li>Cornell Synthesizer Generator<sup id="cite_ref-RepsTeitelbaum1984_10-0" class="reference"><a href="#cite_note-RepsTeitelbaum1984-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup></li>

<li><a rel="nofollow" class="external text" href="https://doi.org/10.4230/LIPIcs.ECOOP.2016.11">IceDust</a> - a custom domain-specific language.</li></ul>

<div class="mw-heading mw-heading3"><h3 id="Frameworks_and_libraries">Frameworks and libraries</h3></div>

<ul><li>Adapton<sup id="cite_ref-11" class="reference"><a href="#cite_note-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup> - with implementations in several languages</li>

<li>One-way Dataflow Constraints (Reactive Computation in C++)</li>

<li>Differential Dataflow</li>

<li>Jane Street <a rel="nofollow" class="external text" href="https://github.com/janestreet/incremental">Incremental</a></li>

<li>Incremental Datalog (<a href="LogicBlox" title="LogicBlox">LogicBlox</a>)</li>

<li>Incremental Prolog (XSB)<sup id="cite_ref-SahaRamakrishnan2005_12-0" class="reference"><a href="#cite_note-SahaRamakrishnan2005-12"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup></li>

<li>Domain-Specific Approaches:

<ul><li>Incremental Type Checking</li></ul></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Applications">Applications</h2></div>

<ul><li>Databases (view maintenance)</li>

<li>Build systems</li>

<li>Spreadsheets<sup id="cite_ref-adapton-pldi2014_13-0" class="reference"><a href="#cite_note-adapton-pldi2014-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup></li>

<li>Development Environments</li>

<li>Financial Computations</li>

<li>Attribute Grammar Evaluation</li>

<li>Graph Computations and Queries</li>

<li>GUIs (e.g., React and DOM diffing)</li>

<li>Scientific applications</li></ul>

<ul><li><a href="Reactive_programming" title="Reactive programming">Reactive programming</a>

<ul><li><a href="Functional_reactive_programming" title="Functional reactive programming">Functional reactive programming</a></li></ul></li>

<li><a href="Memoization" title="Memoization">Memoization</a></li>

<li><a href="Bidirectional_transformation" title="Bidirectional transformation">Bidirectional transformation</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFCarlsson2002" class="citation conference cs1">Carlsson, Magnus (2002). "Monads for incremental computing". <i>Proceedings of the seventh ACM SIGPLAN international conference on Functional programming</i>. New York: <a href="Association_for_Computing_Machinery" title="Association for Computing Machinery">ACM</a>. pp. <span class="nowrap">26–</span>35. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F581478.581482">10.1145/581478.581482</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>1-58113-487-8</bdi>.</cite></span>

</li>

<li id="cite_note-2"><span class="mw-cite-backlink"><b><a href="#cite_ref-2">^</a></b></span> <span class="reference-text"><cite id="CITEREFUmut_A._Acar2005" class="citation thesis cs1">Umut A. Acar (2005). <a rel="nofollow" class="external text" href="https://www.cs.cmu.edu/~rwh/theses/acar.pdf"><i>Self-Adjusting Computation</i></a> <span class="cs1-format">(PDF)</span> (Ph.D. thesis).</cite></span>

</li>

<li id="cite_note-3"><span class="mw-cite-backlink"><b><a href="#cite_ref-3">^</a></b></span> <span class="reference-text"><cite id="CITEREFCamil_DemetrescuIrene_FinocchiAndrea_Ribichini2011" class="citation conference cs1">Camil Demetrescu; Irene Finocchi; Andrea Ribichini (2011). <a rel="nofollow" class="external text" href="https://code.google.com/p/dc-lib/">"Reactive Imperative Programming with Dataflow Constraints"</a>. <i>Proceedings of the 26th ACM International Conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA 2011)</i>. <a href="Association_for_Computing_Machinery" title="Association for Computing Machinery">ACM</a>. pp. <span class="nowrap">407–</span>426. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://arxiv.org/abs/1104.2293">1104.2293</a></span>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F2048066.2048100">10.1145/2048066.2048100</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-4503-0940-0</bdi>.</cite></span>

</li>

<li id="cite_note-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-4">^</a></b></span> <span class="reference-text"><cite id="CITEREFYan_ChenJoshua_DunfieldMatthew_A._HammerUmut_A._Acar" class="citation conference cs1">Yan Chen; Joshua Dunfield; Matthew A. Hammer; Umut A. Acar. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20161030185650/http://repository.cmu.edu/cgi/viewcontent.cgi?article=3549&context=compsci"><i>Implicit self-adjusting computation for purely functional programs</i></a>. ICFP '11. pp. <span class="nowrap">129–</span>141. Archived from <a rel="nofollow" class="external text" href="https://dl.acm.org/citation.cfm?id=2034792">the original</a> on 2016-10-30<span class="reference-accessdate">. Retrieved <span class="nowrap">2018-03-12</span></span>.</cite></span>

</li>

<li id="cite_note-5"><span class="mw-cite-backlink"><b><a href="#cite_ref-5">^</a></b></span> <span class="reference-text"><cite id="CITEREFPaige1981" class="citation book cs1">Paige, Robert (1981). <i>Formal Differentiation: A Program Synthesis Technique</i>. UMI Research Press. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-8357-1213-2</bdi>.</cite></span>

</li>

<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text"><cite id="CITEREFAhmadKennedyKochNikolic2012" class="citation journal cs1">Ahmad, Yanif; Kennedy, Oliver; Koch, Christoph; Nikolic, Milos (2012-06-01). "DBToaster: Higher-order Delta Processing for Dynamic, Frequently Fresh Views". <i>Proc. VLDB Endow</i>. <b>5</b> (10): <span class="nowrap">968–</span>979. <a href="ArXiv_(identifier)" class="mw-redirect" title="ArXiv (identifier)">arXiv</a>:<span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://arxiv.org/abs/1207.0137">1207.0137</a></span>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.14778%2F2336664.2336670">10.14778/2336664.2336670</a>. <a href="ISSN_(identifier)" class="mw-redirect" title="ISSN (identifier)">ISSN</a> <a rel="nofollow" class="external text" href="https://search.worldcat.org/issn/2150-8097">2150-8097</a>.</cite></span>

</li>

<li id="cite_note-7"><span class="mw-cite-backlink"><b><a href="#cite_ref-7">^</a></b></span> <span class="reference-text"><cite id="CITEREFMugilan_MariappanKeval_Vora2019" class="citation conference cs1">Mugilan Mariappan; Keval Vora (2019). "GraphBolt: Dependency-Driven Synchronous Processing of Streaming Graphs". <i>In European Conference on Computer Systems (EuroSys'19)</i>. pp. 25:1–25:16. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F3302424.3303974">10.1145/3302424.3303974</a>.</cite></span>

</li>

<li id="cite_note-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-8">^</a></b></span> <span class="reference-text"><cite id="CITEREFKimberley_BurchettGregory_H._CooperShriram_Krishnamurthi2007" class="citation conference cs1">Kimberley Burchett; Gregory H. Cooper; Shriram Krishnamurthi (2007). "Lowering: A static optimization technique for transparent functional reactivity". <i>In ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation</i>. pp. <span class="nowrap">71–</span>80. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a> <span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.90.5866">10.1.1.90.5866</a></span>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-59593-620-2</bdi>.</cite></span>

</li>

<li id="cite_note-HammerAcar2009-9"><span class="mw-cite-backlink"><b><a href="#cite_ref-HammerAcar2009_9-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFHammerAcarChen2009" class="citation book cs1">Hammer, Matthew A.; Acar, Umut A.; Chen, Yan (2009). "CEAL". <i>Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation - PLDI '09</i>. p. 25. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F1542476.1542480">10.1145/1542476.1542480</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>9781605583921</bdi>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:11058228">11058228</a>.</cite></span>

</li>

<li id="cite_note-RepsTeitelbaum1984-10"><span class="mw-cite-backlink"><b><a href="#cite_ref-RepsTeitelbaum1984_10-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFRepsTeitelbaum1984" class="citation book cs1">Reps, Thomas; Teitelbaum, Tim (1984). "The synthesizer generator". <i>Proceedings of the first ACM SIGSOFT/SIGPLAN software engineering symposium on Practical software development environments - SDE 1</i>. pp. <span class="nowrap">42–</span>48. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F800020.808247">10.1145/800020.808247</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0897911313</bdi>.</cite></span>

</li>

<li id="cite_note-11"><span class="mw-cite-backlink"><b><a href="#cite_ref-11">^</a></b></span> <span class="reference-text"><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://adapton.org">"Adapton: Programming Language Abstractions for Incremental Computation"</a>. <i>adapton.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">2016-10-07</span></span>.</cite></span>

</li>

<li id="cite_note-SahaRamakrishnan2005-12"><span class="mw-cite-backlink"><b><a href="#cite_ref-SahaRamakrishnan2005_12-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFSahaRamakrishnan2005" class="citation book cs1">Saha, Diptikalyan; Ramakrishnan, C. R. (2005). "Incremental Evaluation of Tabled Prolog: Beyond Pure Logic Programs". <i>Practical Aspects of Declarative Languages</i>. Lecture Notes in Computer Science. Vol. 3819. pp. <span class="nowrap">215–</span>229. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a> <span class="id-lock-free" title="Freely accessible"><a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.111.7484">10.1.1.111.7484</a></span>. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1007%2F11603023_15">10.1007/11603023_15</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-3-540-30947-5</bdi>. <a href="ISSN_(identifier)" class="mw-redirect" title="ISSN (identifier)">ISSN</a> <a rel="nofollow" class="external text" href="https://search.worldcat.org/issn/0302-9743">0302-9743</a>.</cite></span>

</li>

<li id="cite_note-adapton-pldi2014-13"><span class="mw-cite-backlink"><b><a href="#cite_ref-adapton-pldi2014_13-0">^</a></b></span> <span class="reference-text"><cite id="CITEREFHammerPhangHicksFoster2014" class="citation conference cs1">Hammer, Matthew; Phang, Khoo; Hicks, Michael; Foster, Jeffrey (2014). <a rel="nofollow" class="external text" href="http://matthewhammer.org/adapton/adapton-pldi2014.pdf"><i>ADAPTON: Composable, Demand-Driven Incremental Computation</i></a> <span class="cs1-format">(PDF)</span>. PLDI.</cite></span>

</li>

</ol></div></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-05-13" href="https://en.wikipedia.org/wiki/?title=Incremental_computing&oldid=1290192634">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>